home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Utilities / Ghostscript / src / zbfont.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-01  |  19.8 KB  |  673 lines
  1. /* Copyright (C) 1989, 1995, 1996, 1997, 1998, 1999, 2000 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of AFPL Ghostscript.
  4.   
  5.   AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6.   distributor accepts any responsibility for the consequences of using it, or
  7.   for whether it serves any particular purpose or works at all, unless he or
  8.   she says so in writing.  Refer to the Aladdin Free Public License (the
  9.   "License") for full details.
  10.   
  11.   Every copy of AFPL Ghostscript must include a copy of the License, normally
  12.   in a plain ASCII text file named PUBLIC.  The License grants you the right
  13.   to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14.   conditions described in the License.  Among other things, the License
  15.   requires that the copyright notice and this notice be preserved on all
  16.   copies.
  17. */
  18.  
  19. /*$Id: zbfont.c,v 1.6 2000/09/19 19:00:52 lpd Exp $ */
  20. /* Font creation utilities */
  21. #include "memory_.h"
  22. #include "string_.h"
  23. #include "ghost.h"
  24. #include "oper.h"
  25. #include "gxfixed.h"
  26. #include "gsmatrix.h"
  27. #include "gxdevice.h"
  28. #include "gxfont.h"
  29. #include "bfont.h"
  30. #include "ialloc.h"
  31. #include "idict.h"
  32. #include "idparam.h"
  33. #include "ilevel.h"
  34. #include "iname.h"
  35. #include "interp.h"        /* for initial_enter_name */
  36. #include "ipacked.h"
  37. #include "istruct.h"
  38. #include "store.h"
  39.  
  40. /* Registered encodings.  See ifont.h for documentation. */
  41. ref registered_Encodings;
  42. private ref *const registered_Encodings_p = ®istered_Encodings;
  43.  
  44. /* Structure descriptor */
  45. public_st_font_data();
  46.  
  47. /* Initialize the font building operators */
  48. private int
  49. zbfont_init(i_ctx_t *i_ctx_p)
  50. {
  51.     /* Initialize the registered Encodings. */
  52.     int i;
  53.  
  54.     ialloc_ref_array(®istered_Encodings, a_all,
  55.              registered_Encodings_countof,
  56.              "registered_Encodings");
  57.     for (i = 0; i < registered_Encodings_countof; i++)
  58.     make_empty_array(®istered_Encoding(i), 0);
  59.     initial_enter_name("registeredencodings", ®istered_Encodings);
  60.     return gs_register_ref_root(imemory, NULL,
  61.                 (void **)®istered_Encodings_p,
  62.                 "registered_Encodings");
  63. }
  64.  
  65. /* <string|name> <font_dict> .buildfont3 <string|name> <font> */
  66. /* Build a type 3 (user-defined) font. */
  67. private int
  68. zbuildfont3(i_ctx_t *i_ctx_p)
  69. {
  70.     os_ptr op = osp;
  71.     int code;
  72.     build_proc_refs build;
  73.     gs_font_base *pfont;
  74.  
  75.     check_type(*op, t_dictionary);
  76.     code = build_gs_font_procs(op, &build);
  77.     if (code < 0)
  78.     return code;
  79.     code = build_gs_simple_font(i_ctx_p, op, &pfont, ft_user_defined,
  80.                 &st_gs_font_base, &build, bf_options_none);
  81.     if (code < 0)
  82.     return code;
  83.     return define_gs_font((gs_font *) pfont);
  84. }
  85.  
  86. /* Encode a character. */
  87. gs_glyph
  88. zfont_encode_char(gs_font *pfont, gs_char chr, gs_glyph_space_t ignored)
  89. {
  90.     const ref *pencoding = &pfont_data(pfont)->Encoding;
  91.     ulong index = chr;    /* work around VAX widening bug */
  92.     ref cname;
  93.     int code = array_get(pencoding, (long)index, &cname);
  94.  
  95.     if (code < 0 || !r_has_type(&cname, t_name))
  96.     return gs_no_glyph;
  97.     return (gs_glyph)name_index(&cname);
  98. }
  99.  
  100. /* Encode a character in a known encoding. */
  101. private gs_glyph
  102. zfont_known_encode(gs_char chr, int encoding_index)
  103. {
  104.     ulong index = chr;        /* work around VAX widening bug */
  105.     ref cname;
  106.     int code;
  107.  
  108.     if (encoding_index < 0)
  109.     return gs_no_glyph;
  110.     code = array_get(®istered_Encoding(encoding_index),
  111.              (long)index, &cname);
  112.     if (code < 0 || !r_has_type(&cname, t_name))
  113.     return gs_no_glyph;
  114.     return (gs_glyph) name_index(&cname);
  115. }
  116.  
  117. /* Get the name of a glyph. */
  118. /* The following typedef is needed to work around a bug in */
  119. /* some AIX C compilers. */
  120. typedef const char *const_chars;
  121. private const_chars
  122. zfont_glyph_name(gs_glyph index, uint * plen)
  123. {
  124.     ref nref, sref;
  125.  
  126.     if (index >= gs_min_cid_glyph) {    /* Fabricate a numeric name. */
  127.     char cid_name[sizeof(gs_glyph) * 3 + 1];
  128.     int code;
  129.  
  130.     sprintf(cid_name, "%lu", (ulong) index);
  131.     code = name_ref((const byte *)cid_name, strlen(cid_name),
  132.             &nref, 1);
  133.     if (code < 0)
  134.         return 0;        /* What can we possibly do here? */
  135.     } else
  136.     name_index_ref(index, &nref);
  137.     name_string_ref(&nref, &sref);
  138.     *plen = r_size(&sref);
  139.     return (const char *)sref.value.const_bytes;
  140. }
  141.  
  142. /* ------ Initialization procedure ------ */
  143.  
  144. const op_def zbfont_op_defs[] =
  145. {
  146.     {"2.buildfont3", zbuildfont3},
  147.     op_def_end(zbfont_init)
  148. };
  149.  
  150. /* ------ Subroutines ------ */
  151.  
  152. /* Convert strings to executable names for build_proc_refs. */
  153. int
  154. build_proc_name_refs(build_proc_refs * pbuild,
  155.              const char *bcstr, const char *bgstr)
  156. {
  157.     int code;
  158.  
  159.     if (!bcstr)
  160.     make_null(&pbuild->BuildChar);
  161.     else {
  162.     if ((code = name_ref((const byte *)bcstr, strlen(bcstr), &pbuild->BuildChar, 0)) < 0)
  163.         return code;
  164.     r_set_attrs(&pbuild->BuildChar, a_executable);
  165.     }
  166.     if (!bgstr)
  167.     make_null(&pbuild->BuildGlyph);
  168.     else {
  169.     if ((code = name_ref((const byte *)bgstr, strlen(bgstr), &pbuild->BuildGlyph, 0)) < 0)
  170.         return code;
  171.     r_set_attrs(&pbuild->BuildGlyph, a_executable);
  172.     }
  173.     return 0;
  174. }
  175.  
  176. /* Get the BuildChar and/or BuildGlyph routines from a (base) font. */
  177. int
  178. build_gs_font_procs(os_ptr op, build_proc_refs * pbuild)
  179. {
  180.     int ccode, gcode;
  181.     ref *pBuildChar;
  182.     ref *pBuildGlyph;
  183.  
  184.     check_type(*op, t_dictionary);
  185.     ccode = dict_find_string(op, "BuildChar", &pBuildChar);
  186.     gcode = dict_find_string(op, "BuildGlyph", &pBuildGlyph);
  187.     if (ccode <= 0) {
  188.     if (gcode <= 0)
  189.         return_error(e_invalidfont);
  190.     make_null(&pbuild->BuildChar);
  191.     } else {
  192.     check_proc(*pBuildChar);
  193.     pbuild->BuildChar = *pBuildChar;
  194.     }
  195.     if (gcode <= 0)
  196.     make_null(&pbuild->BuildGlyph);
  197.     else {
  198.     check_proc(*pBuildGlyph);
  199.     pbuild->BuildGlyph = *pBuildGlyph;
  200.     }
  201.     return 0;
  202. }
  203.  
  204. /* Do the common work for building a primitive font -- one whose execution */
  205. /* algorithm is implemented in C (Type 1, Type 2, Type 4, or Type 42). */
  206. /* The caller guarantees that *op is a dictionary. */
  207. int
  208. build_gs_primitive_font(i_ctx_t *i_ctx_p, os_ptr op, gs_font_base ** ppfont,
  209.             font_type ftype, gs_memory_type_ptr_t pstype,
  210.             const build_proc_refs * pbuild,
  211.             build_font_options_t options)
  212. {
  213.     ref *pcharstrings = 0;
  214.     ref CharStrings;
  215.     gs_font_base *pfont;
  216.     font_data *pdata;
  217.     int code;
  218.  
  219.     if (dict_find_string(op, "CharStrings", &pcharstrings) <= 0) {
  220.     if (!(options & bf_CharStrings_optional))
  221.         return_error(e_invalidfont);
  222.     } else {
  223.     ref *ignore;
  224.  
  225.     if (!r_has_type(pcharstrings, t_dictionary))
  226.         return_error(e_invalidfont);
  227.     if ((options & bf_notdef_required) != 0 &&
  228.         dict_find_string(pcharstrings, ".notdef", &ignore) <= 0
  229.         )
  230.         return_error(e_invalidfont);
  231.     /*
  232.      * Since build_gs_simple_font may resize the dictionary and cause
  233.      * pointers to become invalid, save CharStrings.
  234.      */
  235.     CharStrings = *pcharstrings;
  236.     }
  237.     code = build_gs_outline_font(i_ctx_p, op, ppfont, ftype, pstype, pbuild,
  238.                  options, build_gs_simple_font);
  239.     if (code != 0)
  240.     return code;
  241.     pfont = *ppfont;
  242.     pdata = pfont_data(pfont);
  243.     if (pcharstrings)
  244.     ref_assign(&pdata->CharStrings, &CharStrings);
  245.     else
  246.     make_null(&pdata->CharStrings);
  247.     /* Check that the UniqueIDs match.  This is part of the */
  248.     /* Adobe protection scheme, but we may as well emulate it. */
  249.     if (uid_is_valid(&pfont->UID) &&
  250.     !dict_check_uid_param(op, &pfont->UID)
  251.     )
  252.     uid_set_invalid(&pfont->UID);
  253.     return 0;
  254. }
  255.  
  256. /* Build a FDArray entry for a CIDFontType 0 font. */
  257. /* Note that as of Adobe PostScript version 3011, this may be either */
  258. /* a Type 1 or Type 2 font. */
  259. private int
  260. build_FDArray_sub_font(i_ctx_t *i_ctx_p, ref *op,
  261.                gs_font_base **ppfont,
  262.                font_type ftype, gs_memory_type_ptr_t pstype,
  263.                const build_proc_refs * pbuild,
  264.                build_font_options_t ignore_options)
  265. {
  266.     gs_font *pfont;
  267.     int code = build_gs_sub_font(i_ctx_p, op, &pfont, ftype, pstype, pbuild,
  268.                  NULL, op);
  269.  
  270.     if (code >= 0)
  271.     *ppfont = (gs_font_base *)pfont;
  272.     return code;
  273. }
  274. int
  275. build_gs_FDArray_font(i_ctx_t *i_ctx_p, ref *op,
  276.               gs_font_base **ppfont,
  277.               font_type ftype, gs_memory_type_ptr_t pstype,
  278.               const build_proc_refs * pbuild)
  279. {
  280.     gs_font_base *pfont;
  281.     font_data *pdata;
  282.     int code = build_gs_outline_font(i_ctx_p, op, &pfont, ftype, pstype,
  283.                      pbuild, bf_options_none,
  284.                      build_FDArray_sub_font);
  285.     static const double bbox[4] = { 0, 0, 0, 0 };
  286.     gs_uid uid;
  287.  
  288.     if (code < 0)
  289.     return code;
  290.     pdata = pfont_data(pfont);
  291.     /* Fill in members normally set by build_gs_primitive_font. */
  292.     make_null(&pdata->CharStrings);
  293.     /* Fill in members normally set by build_gs_simple_font. */
  294.     uid_set_invalid(&uid);
  295.     init_gs_simple_font(pfont, bbox, &uid);
  296.     pfont->encoding_index = ENCODING_INDEX_UNKNOWN;
  297.     pfont->nearest_encoding_index = ENCODING_INDEX_UNKNOWN;
  298.     /* Fill in members normally set by build_gs_font. */
  299.     pfont->key_name = pfont->font_name;
  300.     *ppfont = pfont;
  301.     return 0;
  302. }
  303.  
  304. /* Do the common work for building an outline font -- a non-composite font */
  305. /* for which PaintType and StrokeWidth are meaningful. */
  306. /* The caller guarantees that *op is a dictionary. */
  307. int
  308. build_gs_outline_font(i_ctx_t *i_ctx_p, os_ptr op, gs_font_base ** ppfont,
  309.               font_type ftype, gs_memory_type_ptr_t pstype,
  310.               const build_proc_refs * pbuild,
  311.               build_font_options_t options,
  312.               build_base_font_proc_t build_base_font)
  313. {
  314.     int painttype;
  315.     float strokewidth;
  316.     gs_font_base *pfont;
  317.     int code = dict_int_param(op, "PaintType", 0, 3, 0, &painttype);
  318.  
  319.     if (code < 0)
  320.     return code;
  321.     code = dict_float_param(op, "StrokeWidth", 0.0, &strokewidth);
  322.     if (code < 0)
  323.     return code;
  324.     code = build_base_font(i_ctx_p, op, ppfont, ftype, pstype, pbuild,
  325.                options);
  326.     if (code != 0)
  327.     return code;
  328.     pfont = *ppfont;
  329.     pfont->PaintType = painttype;
  330.     pfont->StrokeWidth = strokewidth;
  331.     return 0;
  332. }
  333.  
  334. /* Do the common work for building a font of any non-composite FontType. */
  335. /* The caller guarantees that *op is a dictionary. */
  336. int
  337. build_gs_simple_font(i_ctx_t *i_ctx_p, os_ptr op, gs_font_base ** ppfont,
  338.              font_type ftype, gs_memory_type_ptr_t pstype,
  339.              const build_proc_refs * pbuild,
  340.              build_font_options_t options)
  341. {
  342.     double bbox[4];
  343.     gs_uid uid;
  344.     int code;
  345.     gs_font_base *pfont;
  346.  
  347.     code = font_bbox_param(op, bbox);
  348.     if (code < 0)
  349.     return code;
  350.     if ((options & bf_FontBBox_required) &&
  351.     bbox[0] == 0 && bbox[1] == 0 && bbox[2] == 0 && bbox[3] == 0
  352.     )
  353.     return_error(e_invalidfont);
  354.     code = dict_uid_param(op, &uid, 0, imemory, i_ctx_p);
  355.     if (code < 0)
  356.     return code;
  357.     if ((options & bf_UniqueID_ignored) && uid_is_UniqueID(&uid))
  358.     uid_set_invalid(&uid);
  359.     code = build_gs_font(i_ctx_p, op, (gs_font **) ppfont, ftype, pstype,
  360.              pbuild, options);
  361.     if (code != 0)        /* invalid or scaled font */
  362.     return code;
  363.     pfont = *ppfont;
  364.     pfont->procs.init_fstack = gs_default_init_fstack;
  365.     pfont->procs.define_font = gs_no_define_font;
  366.     pfont->procs.make_font = zbase_make_font;
  367.     pfont->procs.next_char_glyph = gs_default_next_char_glyph;
  368.     init_gs_simple_font(pfont, bbox, &uid);
  369.     lookup_gs_simple_font_encoding(pfont);
  370.     return 0;
  371. }
  372.  
  373. /* Initialize the FontBBox and UID of a non-composite font. */
  374. void
  375. init_gs_simple_font(gs_font_base *pfont, const double bbox[4],
  376.             const gs_uid *puid)
  377. {
  378.     pfont->FontBBox.p.x = bbox[0];
  379.     pfont->FontBBox.p.y = bbox[1];
  380.     pfont->FontBBox.q.x = bbox[2];
  381.     pfont->FontBBox.q.y = bbox[3];
  382.     pfont->UID = *puid;
  383. }
  384.  
  385. /* Compare the encoding of a simple font with the registered encodings. */
  386. void
  387. lookup_gs_simple_font_encoding(gs_font_base * pfont)
  388. {
  389.     const ref *pfe = &pfont_data(pfont)->Encoding;
  390.     int index;
  391.  
  392.     for (index = NUM_KNOWN_REAL_ENCODINGS; --index >= 0;)
  393.     if (obj_eq(pfe, ®istered_Encoding(index)))
  394.         break;
  395.     pfont->encoding_index = index;
  396.     if (index < 0) {        /* Look for an encoding that's "close". */
  397.     int near_index = -1;
  398.     uint esize = r_size(pfe);
  399.     uint best = esize / 3;    /* must match at least this many */
  400.  
  401.     for (index = NUM_KNOWN_REAL_ENCODINGS; --index >= 0;) {
  402.         const ref *pre = ®istered_Encoding(index);
  403.         bool r_packed = r_has_type(pre, t_shortarray);
  404.         bool f_packed = !r_has_type(pfe, t_array);
  405.         uint match = esize;
  406.         int i;
  407.         ref fchar, rchar;
  408.         const ref *pfchar = &fchar;
  409.  
  410.         if (r_size(pre) != esize)
  411.         continue;
  412.         for (i = esize; --i >= 0;) {
  413.         uint rnidx;
  414.  
  415.         if (r_packed)
  416.             rnidx = packed_name_index(pre->value.packed + i);
  417.         else {
  418.             array_get(pre, (long)i, &rchar);
  419.             rnidx = name_index(&rchar);
  420.         }
  421.         if (f_packed)
  422.             array_get(pfe, (long)i, &fchar);
  423.         else
  424.             pfchar = pfe->value.const_refs + i;
  425.         if (!r_has_type(pfchar, t_name) ||
  426.             name_index(pfchar) != rnidx
  427.             )
  428.             if (--match <= best)
  429.             break;
  430.         }
  431.         if (match > best)
  432.         best = match,
  433.             near_index = index;
  434.     }
  435.     index = near_index;
  436.     }
  437.     pfont->nearest_encoding_index = index;
  438. }
  439.  
  440. /* Get FontMatrix and FontName parameters. */
  441. private void get_font_name(P2(ref *, const ref *));
  442. private void copy_font_name(P2(gs_font_name *, const ref *));
  443. private int
  444. sub_font_params(const ref *op, gs_matrix *pmat, ref *pfname)
  445. {
  446.     ref *pmatrix;
  447.     ref *pfontname;
  448.  
  449.     if (dict_find_string(op, "FontMatrix", &pmatrix) <= 0 ||
  450.     read_matrix(pmatrix, pmat) < 0
  451.     )
  452.     return_error(e_invalidfont);
  453.     if (dict_find_string(op, "FontName", &pfontname) > 0)
  454.     get_font_name(pfname, pfontname);
  455.     else
  456.     make_empty_string(pfname, a_readonly);
  457.     return 0;
  458. }
  459.  
  460. /* Do the common work for building a font of any FontType. */
  461. /* The caller guarantees that *op is a dictionary. */
  462. /* op[-1] must be the key under which the font is being registered */
  463. /* in FontDirectory, normally a name or string. */
  464. /* Return 0 for a new font, 1 for a font made by makefont or scalefont, */
  465. /* or a negative error code. */
  466. int
  467. build_gs_font(i_ctx_t *i_ctx_p, os_ptr op, gs_font ** ppfont, font_type ftype,
  468.           gs_memory_type_ptr_t pstype, const build_proc_refs * pbuild,
  469.           build_font_options_t options)
  470. {
  471.     ref kname;            /* t_string */
  472.     ref *pftype;
  473.     ref *pencoding = 0;
  474.     bool bitmapwidths;
  475.     int exactsize, inbetweensize, transformedchar;
  476.     int wmode;
  477.     int code;
  478.     gs_font *pfont;
  479.     ref *pfid;
  480.     ref *aop = dict_access_ref(op);
  481.  
  482.     get_font_name(&kname, op - 1);
  483.     if (dict_find_string(op, "FontType", &pftype) <= 0 ||
  484.     !r_has_type(pftype, t_integer) ||
  485.     pftype->value.intval != (int)ftype
  486.     )
  487.     return_error(e_invalidfont);
  488.     if (dict_find_string(op, "Encoding", &pencoding) <= 0) {
  489.     if (!(options & bf_Encoding_optional))
  490.         return_error(e_invalidfont);
  491.     } else {
  492.     if (!r_is_array(pencoding))
  493.         return_error(e_invalidfont);
  494.     }
  495.     if ((code = dict_int_param(op, "WMode", 0, 1, 0, &wmode)) < 0 ||
  496.     (code = dict_bool_param(op, "BitmapWidths", false, &bitmapwidths)) < 0 ||
  497.     (code = dict_int_param(op, "ExactSize", 0, 2, fbit_use_bitmaps, &exactsize)) < 0 ||
  498.     (code = dict_int_param(op, "InBetweenSize", 0, 2, fbit_use_outlines, &inbetweensize)) < 0 ||
  499.     (code = dict_int_param(op, "TransformedChar", 0, 2, fbit_use_outlines, &transformedchar)) < 0
  500.     )
  501.     return code;
  502.     code = dict_find_string(op, "FID", &pfid);
  503.     if (code > 0) {
  504.     if (!r_has_type(pfid, t_fontID))
  505.         return_error(e_invalidfont);
  506.     /*
  507.      * If this font has a FID entry already, it might be
  508.      * a scaled font made by makefont or scalefont;
  509.      * in a Level 2 environment, it might be an existing font
  510.      * being registered under a second name, or a re-encoded
  511.      * font (which is questionable PostScript, but dvips
  512.      * is known to do this).
  513.      */
  514.     pfont = r_ptr(pfid, gs_font);
  515.     if (pfont->base == pfont) {    /* original font */
  516.         if (!level2_enabled)
  517.         return_error(e_invalidfont);
  518.         if (obj_eq(pfont_dict(pfont), op)) {
  519.         *ppfont = pfont;
  520.         return 1;
  521.         }
  522.         /*
  523.          * This is a re-encoded font, or some other
  524.          * questionable situation in which the FID
  525.          * was preserved.  Pretend the FID wasn't there.
  526.          */
  527.     } else {        /* This was made by makefont or scalefont. */
  528.         /* Just insert the new name. */
  529.         gs_matrix mat;
  530.         ref fname;            /* t_string */
  531.  
  532.         code = sub_font_params(op, &mat, &fname);
  533.         if (code < 0)
  534.         return code;
  535.         code = 1;
  536.         copy_font_name(&pfont->font_name, &fname);
  537.         goto set_name;
  538.     }
  539.     }
  540.     /* This is a new font. */
  541.     if (!r_has_attr(aop, a_write))
  542.     return_error(e_invalidaccess);
  543.     {
  544.     ref encoding;
  545.  
  546.     /*
  547.      * Since add_FID may resize the dictionary and cause
  548.      * pencoding to become invalid, save the Encoding.
  549.      */
  550.     if (pencoding) {
  551.         encoding = *pencoding;
  552.         pencoding = &encoding;
  553.     }
  554.     code = build_gs_sub_font(i_ctx_p, op, &pfont, ftype, pstype,
  555.                  pbuild, pencoding, op);
  556.     if (code < 0)
  557.         return code;
  558.     }
  559.     pfont->BitmapWidths = bitmapwidths;
  560.     pfont->ExactSize = (fbit_type)exactsize;
  561.     pfont->InBetweenSize = (fbit_type)inbetweensize;
  562.     pfont->TransformedChar = (fbit_type)transformedchar;
  563.     pfont->WMode = wmode;
  564.     code = 0;
  565. set_name:
  566.     copy_font_name(&pfont->key_name, &kname);
  567.     *ppfont = pfont;
  568.     return code;
  569. }
  570.  
  571. /* Create a sub-font -- a font or an entry in the FDArray of a CIDFontType 0 */
  572. /* font.  Default BitmapWidths, ExactSize, InBetweenSize, TransformedChar, */
  573. /* and WMode; do not fill in key_name. */
  574. /* The caller guarantees that *op is a dictionary. */
  575. int
  576. build_gs_sub_font(i_ctx_t *i_ctx_p, const ref *op, gs_font **ppfont,
  577.           font_type ftype, gs_memory_type_ptr_t pstype,
  578.           const build_proc_refs * pbuild, const ref *pencoding,
  579.           ref *fid_op)
  580. {
  581.     gs_matrix mat;
  582.     ref fname;            /* t_string */
  583.     gs_font *pfont;
  584.     font_data *pdata;
  585.     /*
  586.      * Make sure that we allocate the font data
  587.      * in the same VM as the font dictionary.
  588.      */
  589.     uint space = ialloc_space(idmemory);
  590.     int code = sub_font_params(op, &mat, &fname);
  591.  
  592.     if (code < 0)
  593.     return code;
  594.     ialloc_set_space(idmemory, r_space(op));
  595.     pfont = gs_font_alloc(imemory, pstype, &gs_font_procs_default, NULL,
  596.               "buildfont(font)");
  597.     pdata = ialloc_struct(font_data, &st_font_data,
  598.               "buildfont(data)");
  599.     if (pfont == 0 || pdata == 0)
  600.     code = gs_note_error(e_VMerror);
  601.     else if (fid_op)
  602.     code = add_FID(i_ctx_p, fid_op, pfont, iimemory);
  603.     if (code < 0) {
  604.     ifree_object(pdata, "buildfont(data)");
  605.     ifree_object(pfont, "buildfont(font)");
  606.     ialloc_set_space(idmemory, space);
  607.     return code;
  608.     }
  609.     refset_null((ref *) pdata, sizeof(font_data) / sizeof(ref));
  610.     ref_assign_new(&pdata->dict, op);
  611.     ref_assign_new(&pdata->BuildChar, &pbuild->BuildChar);
  612.     ref_assign_new(&pdata->BuildGlyph, &pbuild->BuildGlyph);
  613.     if (pencoding)
  614.     ref_assign_new(&pdata->Encoding, pencoding);
  615.     pfont->client_data = pdata;
  616.     pfont->FontType = ftype;
  617.     pfont->FontMatrix = mat;
  618.     pfont->BitmapWidths = false;
  619.     pfont->ExactSize = fbit_use_bitmaps;
  620.     pfont->InBetweenSize = fbit_use_outlines;
  621.     pfont->TransformedChar = fbit_use_outlines;
  622.     pfont->WMode = 0;
  623.     pfont->procs.encode_char = zfont_encode_char;
  624.     pfont->procs.callbacks.glyph_name = zfont_glyph_name;
  625.     pfont->procs.callbacks.known_encode = zfont_known_encode;
  626.     ialloc_set_space(idmemory, space);
  627.     copy_font_name(&pfont->font_name, &fname);
  628.     *ppfont = pfont;
  629.     return 0;
  630. }
  631.  
  632. /* Get the string corresponding to a font name. */
  633. /* If the font name isn't a name or a string, return an empty string. */
  634. private void
  635. get_font_name(ref * pfname, const ref * op)
  636. {
  637.     switch (r_type(op)) {
  638.     case t_string:
  639.         *pfname = *op;
  640.         break;
  641.     case t_name:
  642.         name_string_ref(op, pfname);
  643.         break;
  644.     default:
  645.         /* This is weird, but legal.... */
  646.         make_empty_string(pfname, a_readonly);
  647.     }
  648. }
  649.  
  650. /* Copy a font name into the gs_font structure. */
  651. private void
  652. copy_font_name(gs_font_name * pfstr, const ref * pfname)
  653. {
  654.     uint size = r_size(pfname);
  655.  
  656.     if (size > gs_font_name_max)
  657.     size = gs_font_name_max;
  658.     memcpy(&pfstr->chars[0], pfname->value.const_bytes, size);
  659.     /* Following is only for debugging printout. */
  660.     pfstr->chars[size] = 0;
  661.     pfstr->size = size;
  662. }
  663.  
  664. /* Finish building a font, by calling gs_definefont if needed. */
  665. int
  666. define_gs_font(gs_font * pfont)
  667. {
  668.     return (pfont->base == pfont && pfont->dir == 0 ?
  669.         /* i.e., unregistered original font */
  670.         gs_definefont(ifont_dir, pfont) :
  671.         0);
  672. }
  673.